import pygame
import os
import json

class Hero:
    def __init__(self, x, y, width=50, height=50):
        # 加载英雄贴图
        image_path = "assets/characters/hero/hero.png"
        self.image = pygame.image.load(image_path)
        self.image = pygame.transform.scale(self.image, (width, height))  # 调整大小
        self.rect = self.image.get_rect()  # 贴图的矩形区域
        self.rect.x = x - width // 2  # 调整初始位置，使中心点对齐
        self.rect.y = y - height // 2  # 调整初始位置，使中心点对齐

        # 路径相关属性
        self.path_points = []  # 路径点（原始坐标）
        self.scaled_path_points = []  # 路径点（映射后的坐标）
        self.current_path_index = 0  # 当前路径点索引
        self.move_pixels = 0  # 记录待移动的像素数
        self.map_change_points = {}  # 存储更换地图的指定位置（原始坐标）及对应地图索引

        self.original_path_points = []  # 新增：存储原始路径点（未缩放的坐标）
        self.current_display_scale = 1.0  # 当前显示缩放比例

        # 坐标系统
        self.logical_pos = (x, y)  # 逻辑坐标（原始坐标）
        self.display_pos = (x, y)   # 显示坐标
        self.display_offset = (0, 0)  # 显示坐标偏移量
        self.original_map_size = (0, 0)  # 原始地图尺寸
        self.current_screen_size = (0, 0)  # 当前屏幕尺寸

        self.char_move_speed = 7  # 每正确输入一个字符移动的像素数
        self.move_pixels = 0  # 累计待移动的像素数
        self.current_segment_progress = 0  # 当前路径段的进度

    def calculate_display_position(self, map_rect, original_map_size):
        """
        计算英雄显示坐标
        :param map_rect: 地图显示区域 (x, y, width, height)
        :param original_map_size: 原始地图尺寸 (width, height)
        """
        # 更新当前屏幕尺寸和原始地图尺寸
        self.current_screen_size = (map_rect.width, map_rect.height)
        self.original_map_size = original_map_size
        
        # 计算显示坐标
        scale_x = map_rect.width / original_map_size[0]
        scale_y = map_rect.height / original_map_size[1]
        scale = min(scale_x, scale_y)  # 保持比例
        
        # 计算地图显示区域的偏移量（居中）
        display_width = original_map_size[0] * scale
        display_height = original_map_size[1] * scale
        map_x = map_rect.x + (map_rect.width - display_width) // 2
        map_y = map_rect.y + (map_rect.height - display_height) // 2
        
        # 变换坐标
        display_x = int(self.logical_pos[0] * scale) + map_x
        display_y = int(self.logical_pos[1] * scale) + map_y
        
        # 更新显示坐标
        self.display_pos = (display_x, display_y)
        
        # 更新英雄图标位置（中心对齐）
        self.rect.x = display_x - self.rect.width // 2
        self.rect.y = display_y - self.rect.height // 2

    def load_path(self, path_file, map_width, map_height, scaled_width, scaled_height, map_x, map_y):
        """
        加载路径点，只使用原始坐标
        """
        with open(path_file, 'r') as f:
            data = json.load(f)
            self.path_points = data["path_points"]  # 只加载原始路径点
            # 将字符串键转换回元组
            self.map_change_points = {eval(k): v for k, v in data["map_change_points"].items()}
            self.original_map_size = tuple(data["image_resolution"])  # 保存原始地图分辨率

        # 打印路径点信息
        print(f"[Hero] 加载路径完成，共 {len(self.path_points)} 个路径点")
        for i, point in enumerate(self.path_points):
            print(f"[Hero] 路径点 {i}: {point[0]}, {point[1]}")

        # 仅在第一次加载路径时设置英雄初始位置为第一个路径点
        if len(self.path_points) > 0 and self.current_path_index == 0:
            self.logical_pos = self.path_points[0]  # 设置初始逻辑坐标
            print(f"[Hero] 初始位置设置为第一个路径点: {self.logical_pos[0]}, {self.logical_pos[1]}")
            
            # 打印下一个路径点（如果有）
            if len(self.path_points) > 1:
                next_x, next_y = self.path_points[1]
                print(f"[Hero] 下一个路径点位置: {next_x}, {next_y}")

    def update(self):
        """根据累计的待移动像素数更新位置"""
        if self.move_pixels > 0 and len(self.path_points) > 1:
            if self.current_path_index < len(self.path_points) - 1:
                # 获取当前和目标路径点的原始坐标
                current_x, current_y = self.path_points[self.current_path_index]
                target_x, target_y = self.path_points[self.current_path_index + 1]
                
                # 计算当前路径段的总长度
                segment_dx = target_x - current_x
                segment_dy = target_y - current_y
                segment_length = (segment_dx ** 2 + segment_dy ** 2) ** 0.5
                
                # 计算本次可以移动的距离
                remaining_segment = segment_length - self.current_segment_progress
                move_distance = min(self.move_pixels, remaining_segment)
                
                # 计算新位置
                ratio = move_distance / segment_length if segment_length > 0 else 0
                new_x = current_x + segment_dx * (self.current_segment_progress + move_distance) / segment_length
                new_y = current_y + segment_dy * (self.current_segment_progress + move_distance) / segment_length
                
                # 更新状态
                self.logical_pos = (new_x, new_y)
                self.current_segment_progress += move_distance
                self.move_pixels -= move_distance
                
                # 检查是否到达路径点（包括地图切换点）
                if self.current_segment_progress >= segment_length:
                    self.current_path_index += 1
                    self.current_segment_progress = 0
                    
                    # 通知游戏检查地图切换
                    if hasattr(self, 'game'):
                        self.game.check_map_transition()

    def draw(self, screen):
        screen.blit(self.image, self.rect)

    def add_move_pixels(self, pixels):
        """增加待移动的像素数"""
        self.move_pixels += pixels

    def set_char_move_speed(self, speed):
        """设置每正确输入一个字符移动的像素数"""
        self.char_move_speed = speed

    def has_reached_end(self):
        """检查是否到达路径终点"""
        return self.current_path_index >= len(self.path_points) - 1